{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fast training with MONAI features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial shows a regular PyTorch training program and a MONAI optimized training program, and compared the performance.  \n",
    "Mainly includes:\n",
    "1. AMP (Auto mixed precision).\n",
    "2. CacheDataset for deterministic transforms.\n",
    "3. Move data to GPU and cache, then execute random transforms on GPU.\n",
    "4. multi-threads `ThreadDataLoader` is faster than PyTorch DataLoader in light-weight task.\n",
    "5. Use MONAI `DiceCE` loss instead of regular `Dice` loss.\n",
    "6. Use MONAI `Novograd` optimizer instead of regular `Adam` optimizer.\n",
    "\n",
    "With a V100 GPU, we are able to achieve the training converges at a validation mean dice of `0.95` within `1 minute`,  it's approximately `200x` speedup compared with the Pytorch regular implementation when achieving same metric. And every epoch is `20x` faster than regular training.\n",
    "\n",
    "It's modified from the Spleen 3D segmentation tutorial notebook, the Spleen dataset can be downloaded from http://medicaldecathlon.com/.\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Project-MONAI/tutorials/blob/master/acceleration/fast_training_tutorial.ipynb)(* please note that the free GPU resource in Colab may be not as powerful as the V100 test results in this notebook: it may not support AMP and the GPU computation of transforms may be not faster than the CPU computation.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "!python -c \"import monai\" || pip install -q \"monai-weekly[nibabel, tqdm]\"\n",
    "!python -c \"import matplotlib\" || pip install -q matplotlib\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copyright 2020 MONAI Consortium\n",
    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#     http://www.apache.org/licenses/LICENSE-2.0\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License.\n",
    "\n",
    "import glob\n",
    "import math\n",
    "import os\n",
    "import shutil\n",
    "import tempfile\n",
    "import time\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from torch.optim import Adam\n",
    "from monai.apps import download_and_extract\n",
    "from monai.config import print_config\n",
    "from monai.data import (\n",
    "    CacheDataset,\n",
    "    DataLoader,\n",
    "    ThreadDataLoader,\n",
    "    Dataset,\n",
    "    decollate_batch,\n",
    ")\n",
    "from monai.inferers import sliding_window_inference\n",
    "from monai.losses import DiceLoss, DiceCELoss\n",
    "from monai.metrics import DiceMetric\n",
    "from monai.networks.layers import Norm\n",
    "from monai.networks.nets import UNet\n",
    "from monai.optimizers import Novograd\n",
    "from monai.transforms import (\n",
    "    AddChanneld,\n",
    "    AsDiscrete,\n",
    "    Compose,\n",
    "    CropForegroundd,\n",
    "    FgBgToIndicesd,\n",
    "    LoadImaged,\n",
    "    Orientationd,\n",
    "    RandCropByPosNegLabeld,\n",
    "    ScaleIntensityRanged,\n",
    "    Spacingd,\n",
    "    ToDeviced,\n",
    "    EnsureTyped,\n",
    "    EnsureType,\n",
    ")\n",
    "from monai.utils import get_torch_version_tuple, set_determinism\n",
    "\n",
    "print_config()\n",
    "\n",
    "if get_torch_version_tuple() < (1, 6):\n",
    "    raise RuntimeError(\n",
    "        \"AMP feature only exists in PyTorch version greater than v1.6.\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup data directory\n",
    "\n",
    "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable.  \n",
    "This allows you to save results and reuse downloads.  \n",
    "If not specified a temporary directory will be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root dir is: /workspace/data/medical\n"
     ]
    }
   ],
   "source": [
    "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
    "root_dir = tempfile.mkdtemp() if directory is None else directory\n",
    "print(f\"root dir is: {root_dir}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download dataset\n",
    "\n",
    "Downloads and extracts the Decathlon Spleen dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "resource = \"https://msd-for-monai.s3-us-west-2.amazonaws.com/Task09_Spleen.tar\"\n",
    "md5 = \"410d4a301da4e5b2f6f86ec3ddba524e\"\n",
    "\n",
    "compressed_file = os.path.join(root_dir, \"Task09_Spleen.tar\")\n",
    "data_root = os.path.join(root_dir, \"Task09_Spleen\")\n",
    "if not os.path.exists(data_root):\n",
    "    download_and_extract(resource, compressed_file, root_dir, md5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set MSD Spleen dataset path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_images = sorted(\n",
    "    glob.glob(os.path.join(data_root, \"imagesTr\", \"*.nii.gz\"))\n",
    ")\n",
    "train_labels = sorted(\n",
    "    glob.glob(os.path.join(data_root, \"labelsTr\", \"*.nii.gz\"))\n",
    ")\n",
    "data_dicts = [\n",
    "    {\"image\": image_name, \"label\": label_name}\n",
    "    for image_name, label_name in zip(train_images, train_labels)\n",
    "]\n",
    "train_files, val_files = data_dicts[:-9], data_dicts[-9:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup transforms for training and validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transformations(fast=False):\n",
    "    train_transforms = [\n",
    "        LoadImaged(keys=[\"image\", \"label\"]),\n",
    "        AddChanneld(keys=[\"image\", \"label\"]),\n",
    "        Spacingd(\n",
    "            keys=[\"image\", \"label\"],\n",
    "            pixdim=(1.5, 1.5, 2.0),\n",
    "            mode=(\"bilinear\", \"nearest\"),\n",
    "        ),\n",
    "        Orientationd(keys=[\"image\", \"label\"], axcodes=\"RAS\"),\n",
    "        ScaleIntensityRanged(\n",
    "            keys=[\"image\"],\n",
    "            a_min=-57,\n",
    "            a_max=164,\n",
    "            b_min=0.0,\n",
    "            b_max=1.0,\n",
    "            clip=True,\n",
    "        ),\n",
    "        CropForegroundd(keys=[\"image\", \"label\"], source_key=\"image\"),\n",
    "        # pre-compute foreground and background indexes\n",
    "        # and cache them to accelerate training\n",
    "        FgBgToIndicesd(\n",
    "            keys=\"label\",\n",
    "            fg_postfix=\"_fg\",\n",
    "            bg_postfix=\"_bg\",\n",
    "            image_key=\"image\",\n",
    "        ),\n",
    "        # change to execute transforms with Tensor data\n",
    "        EnsureTyped(keys=[\"image\", \"label\"]),\n",
    "    ]\n",
    "    if fast:\n",
    "        # move the data to GPU and cache to avoid CPU -> GPU sync in every epoch\n",
    "        train_transforms.append(\n",
    "            ToDeviced(keys=[\"image\", \"label\"], device=\"cuda:0\")\n",
    "        )\n",
    "    train_transforms.append(\n",
    "        # randomly crop out patch samples from big\n",
    "        # image based on pos / neg ratio\n",
    "        # the image centers of negative samples\n",
    "        # must be in valid image area\n",
    "        RandCropByPosNegLabeld(\n",
    "            keys=[\"image\", \"label\"],\n",
    "            label_key=\"label\",\n",
    "            spatial_size=(96, 96, 96),\n",
    "            pos=1,\n",
    "            neg=1,\n",
    "            num_samples=4,\n",
    "            fg_indices_key=\"label_fg\",\n",
    "            bg_indices_key=\"label_bg\",\n",
    "        ),\n",
    "    )\n",
    "\n",
    "    val_transforms = [\n",
    "        LoadImaged(keys=[\"image\", \"label\"]),\n",
    "        AddChanneld(keys=[\"image\", \"label\"]),\n",
    "        Spacingd(\n",
    "            keys=[\"image\", \"label\"],\n",
    "            pixdim=(1.5, 1.5, 2.0),\n",
    "            mode=(\"bilinear\", \"nearest\"),\n",
    "        ),\n",
    "        Orientationd(keys=[\"image\", \"label\"], axcodes=\"RAS\"),\n",
    "        ScaleIntensityRanged(\n",
    "            keys=[\"image\"],\n",
    "            a_min=-57,\n",
    "            a_max=164,\n",
    "            b_min=0.0,\n",
    "            b_max=1.0,\n",
    "            clip=True,\n",
    "        ),\n",
    "        CropForegroundd(keys=[\"image\", \"label\"], source_key=\"image\"),\n",
    "        EnsureTyped(keys=[\"image\", \"label\"]),\n",
    "    ]\n",
    "    if fast:\n",
    "        # move the data to GPU and cache to avoid CPU -> GPU sync in every epoch\n",
    "        val_transforms.append(\n",
    "            ToDeviced(keys=[\"image\", \"label\"], device=\"cuda:0\")\n",
    "        )\n",
    "\n",
    "    return Compose(train_transforms), Compose(val_transforms)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the training progress\n",
    "For a typical PyTorch regular training procedure, use regular `Dataset`, `DataLoader`, `Adam` optimizer and `Dice` loss to train the model.\n",
    "\n",
    "For MONAI fast training progress, we mainly introduce the following features:\n",
    "1. `AMP` (auto mixed precision): AMP is an important feature released in PyTorch v1.6, NVIDIA CUDA 11 added strong support for AMP and significantly improved training speed.\n",
    "2. `CacheDataset`: Dataset with the cache mechanism that can load data and cache deterministic transforms' result during training.\n",
    "3. `ToDeviced` transform: to move data to GPU and cache with `CacheDataset`, then execute random transforms on GPU directly, avoid CPU -> GPU sync in every epoch. Please note that not all the MONAI transforms support GPU operation so far, still working in progress.\n",
    "4. `ThreadDataLoader`: uses multi-threads instead of multi-processing, faster than `DataLoader` in light-weight task as we already cached the results of most computation.\n",
    "5. `Novograd` optimizer: Novograd is based on the paper \"Stochastic Gradient Methods with Layer-wise Adaptive Moments for Training of Deep Networks\" `<https://arxiv.org/pdf/1905.11286.pdf>`.\n",
    "6. `DiceCE` loss function: computes Dice loss and Cross Entropy Loss, returns the weighted sum of these two losses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def train_process(fast=False):\n",
    "    max_epochs = 300\n",
    "    learning_rate = 2e-4\n",
    "    val_interval = 1  # do validation for every epoch\n",
    "\n",
    "    train_trans, val_trans = transformations(fast=fast)\n",
    "    # set CacheDataset, ThreadDataLoader and DiceCE loss for MONAI fast training\n",
    "    if fast:\n",
    "        # as `RandCropByPosNegLabeld` crops from the cached content and `deepcopy`\n",
    "        # the crop area instead of modifying the cached value, we can set `copy_cache=False`\n",
    "        # to avoid unnecessary deepcopy of cached content in `CacheDataset`\n",
    "        train_ds = CacheDataset(\n",
    "            data=train_files,\n",
    "            transform=train_trans,\n",
    "            cache_rate=1.0,\n",
    "            num_workers=8,\n",
    "            copy_cache=False,\n",
    "        )\n",
    "        val_ds = CacheDataset(\n",
    "            data=val_files, transform=val_trans, cache_rate=1.0, num_workers=5, copy_cache=False\n",
    "        )\n",
    "        # disable multi-workers because `ThreadDataLoader` works with multi-threads\n",
    "        train_loader = ThreadDataLoader(train_ds, num_workers=0, batch_size=4, shuffle=True)\n",
    "        val_loader = ThreadDataLoader(val_ds, num_workers=0, batch_size=1)\n",
    "        loss_function = DiceCELoss(to_onehot_y=True, softmax=True, squared_pred=True, batch=True)\n",
    "    else:\n",
    "        train_ds = Dataset(data=train_files, transform=train_trans)\n",
    "        val_ds = Dataset(data=val_files, transform=val_trans)\n",
    "        # num_worker=4 is the best parameter according to the test\n",
    "        train_loader = DataLoader(train_ds, batch_size=4, shuffle=True, num_workers=4)\n",
    "        val_loader = DataLoader(val_ds, batch_size=1, num_workers=4)\n",
    "        loss_function = DiceLoss(to_onehot_y=True, softmax=True)\n",
    "\n",
    "    device = torch.device(\"cuda:0\")\n",
    "    model = UNet(\n",
    "        spatial_dims=3,\n",
    "        in_channels=1,\n",
    "        out_channels=2,\n",
    "        channels=(16, 32, 64, 128, 256),\n",
    "        strides=(2, 2, 2, 2),\n",
    "        num_res_units=2,\n",
    "        norm=Norm.BATCH,\n",
    "    ).to(device)\n",
    "\n",
    "    post_pred = Compose([EnsureType(), AsDiscrete(argmax=True, to_onehot=True, num_classes=2)])\n",
    "    post_label = Compose([EnsureType(), AsDiscrete(to_onehot=True, num_classes=2)])\n",
    "\n",
    "    dice_metric = DiceMetric(include_background=True, reduction=\"mean\", get_not_nans=False)\n",
    "\n",
    "    # set Novograd optimizer for MONAI training\n",
    "    if fast:\n",
    "        # Novograd paper suggests to use a bigger LR than Adam,\n",
    "        # because Adam does normalization by element-wise second moments\n",
    "        optimizer = Novograd(model.parameters(), learning_rate * 10)\n",
    "        scaler = torch.cuda.amp.GradScaler()\n",
    "    else:\n",
    "        optimizer = Adam(model.parameters(), learning_rate)\n",
    "\n",
    "    best_metric = -1\n",
    "    best_metric_epoch = -1\n",
    "    best_metrics_epochs_and_time = [[], [], []]\n",
    "    epoch_loss_values = []\n",
    "    metric_values = []\n",
    "    epoch_times = []\n",
    "    total_start = time.time()\n",
    "    for epoch in range(max_epochs):\n",
    "        epoch_start = time.time()\n",
    "        print(\"-\" * 10)\n",
    "        print(f\"epoch {epoch + 1}/{max_epochs}\")\n",
    "        model.train()\n",
    "        epoch_loss = 0\n",
    "        step = 0\n",
    "        for batch_data in train_loader:\n",
    "            step_start = time.time()\n",
    "            step += 1\n",
    "            inputs, labels = (\n",
    "                batch_data[\"image\"].to(device),\n",
    "                batch_data[\"label\"].to(device),\n",
    "            )\n",
    "            optimizer.zero_grad()\n",
    "            # set AMP for MONAI training\n",
    "            if fast:\n",
    "                with torch.cuda.amp.autocast():\n",
    "                    outputs = model(inputs)\n",
    "                    loss = loss_function(outputs, labels)\n",
    "                scaler.scale(loss).backward()\n",
    "                scaler.step(optimizer)\n",
    "                scaler.update()\n",
    "            else:\n",
    "                outputs = model(inputs)\n",
    "                loss = loss_function(outputs, labels)\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "            epoch_loss += loss.item()\n",
    "            epoch_len = math.ceil(len(train_ds) / train_loader.batch_size)\n",
    "            print(\n",
    "                f\"{step}/{epoch_len}, train_loss: {loss.item():.4f}\"\n",
    "                f\" step time: {(time.time() - step_start):.4f}\"\n",
    "            )\n",
    "        epoch_loss /= step\n",
    "        epoch_loss_values.append(epoch_loss)\n",
    "        print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n",
    "\n",
    "        if (epoch + 1) % val_interval == 0:\n",
    "            model.eval()\n",
    "            with torch.no_grad():\n",
    "                for val_data in val_loader:\n",
    "                    val_inputs, val_labels = (\n",
    "                        val_data[\"image\"].to(device),\n",
    "                        val_data[\"label\"].to(device),\n",
    "                    )\n",
    "                    roi_size = (160, 160, 160)\n",
    "                    sw_batch_size = 4\n",
    "                    # set AMP for MONAI validation\n",
    "                    if fast:\n",
    "                        with torch.cuda.amp.autocast():\n",
    "                            val_outputs = sliding_window_inference(\n",
    "                                val_inputs, roi_size, sw_batch_size, model\n",
    "                            )\n",
    "                    else:\n",
    "                        val_outputs = sliding_window_inference(\n",
    "                            val_inputs, roi_size, sw_batch_size, model\n",
    "                        )\n",
    "                    val_outputs = [post_pred(i) for i in decollate_batch(val_outputs)]\n",
    "                    val_labels = [post_label(i) for i in decollate_batch(val_labels)]\n",
    "                    dice_metric(y_pred=val_outputs, y=val_labels)\n",
    "\n",
    "                metric = dice_metric.aggregate().item()\n",
    "                dice_metric.reset()\n",
    "                metric_values.append(metric)\n",
    "                if metric > best_metric:\n",
    "                    best_metric = metric\n",
    "                    best_metric_epoch = epoch + 1\n",
    "                    best_metrics_epochs_and_time[0].append(best_metric)\n",
    "                    best_metrics_epochs_and_time[1].append(best_metric_epoch)\n",
    "                    best_metrics_epochs_and_time[2].append(\n",
    "                        time.time() - total_start\n",
    "                    )\n",
    "                    torch.save(model.state_dict(), \"best_metric_model.pth\")\n",
    "                    print(\"saved new best metric model\")\n",
    "                print(\n",
    "                    f\"current epoch: {epoch + 1} current\"\n",
    "                    f\" mean dice: {metric:.4f}\"\n",
    "                    f\" best mean dice: {best_metric:.4f}\"\n",
    "                    f\" at epoch: {best_metric_epoch}\"\n",
    "                )\n",
    "        print(\n",
    "            f\"time consuming of epoch {epoch + 1} is:\"\n",
    "            f\" {(time.time() - epoch_start):.4f}\"\n",
    "        )\n",
    "        epoch_times.append(time.time() - epoch_start)\n",
    "\n",
    "    total_time = time.time() - total_start\n",
    "    print(\n",
    "        f\"train completed, best_metric: {best_metric:.4f}\"\n",
    "        f\" at epoch: {best_metric_epoch}\"\n",
    "        f\" total time: {total_time:.4f}\"\n",
    "    )\n",
    "    return (\n",
    "        max_epochs,\n",
    "        epoch_loss_values,\n",
    "        metric_values,\n",
    "        epoch_times,\n",
    "        best_metrics_epochs_and_time,\n",
    "        total_time,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enable determinism and execute regular PyTorch training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_determinism(seed=0)\n",
    "regular_start = time.time()\n",
    "(\n",
    "    epoch_num,\n",
    "    epoch_loss_values,\n",
    "    metric_values,\n",
    "    epoch_times,\n",
    "    best,\n",
    "    train_time,\n",
    ") = train_process(fast=False)\n",
    "total_time = time.time() - regular_start\n",
    "print(\n",
    "    f\"total time of {epoch_num} epochs with regular PyTorch training: {total_time:.4f}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enable determinism and execute MONAI optimized training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_determinism(seed=0)\n",
    "monai_start = time.time()\n",
    "(\n",
    "    epoch_num,\n",
    "    m_epoch_loss_values,\n",
    "    m_metric_values,\n",
    "    m_epoch_times,\n",
    "    m_best,\n",
    "    m_train_time,\n",
    ") = train_process(fast=True)\n",
    "m_total_time = time.time() - monai_start\n",
    "print(\n",
    "    f\"total time of {epoch_num} epochs with MONAI fast training: {m_train_time:.4f},\"\n",
    "    f\" time of preparing cache: {(m_total_time - m_train_time):.4f}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot training loss and validation metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(\"train\", (12, 12))\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.title(\"Regular Epoch Average Loss\")\n",
    "x = [i + 1 for i in range(len(epoch_loss_values))]\n",
    "y = epoch_loss_values\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.plot(x, y, color=\"red\")\n",
    "\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.title(\"Regular Val Mean Dice\")\n",
    "x = [i + 1 for i in range(len(metric_values))]\n",
    "y = metric_values\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.ylim(0, 1)\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.plot(x, y, color=\"red\")\n",
    "\n",
    "plt.subplot(2, 2, 3)\n",
    "plt.title(\"Fast Epoch Average Loss\")\n",
    "x = [i + 1 for i in range(len(m_epoch_loss_values))]\n",
    "y = m_epoch_loss_values\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.plot(x, y, color=\"green\")\n",
    "\n",
    "plt.subplot(2, 2, 4)\n",
    "plt.title(\"Fast Val Mean Dice\")\n",
    "x = [i + 1 for i in range(len(m_metric_values))]\n",
    "y = m_metric_values\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.ylim(0, 1)\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.plot(x, y, color=\"green\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot total time and every epoch time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(\"train\", (12, 6))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.title(\"Total Train Time(300 epochs)\")\n",
    "plt.bar(\n",
    "    \"regular PyTorch\", total_time, 1, label=\"Regular training\", color=\"red\"\n",
    ")\n",
    "plt.bar(\"Fast\", m_total_time, 1, label=\"Fast training\", color=\"green\")\n",
    "plt.ylabel(\"secs\")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.title(\"Epoch Time\")\n",
    "x = [i + 1 for i in range(len(epoch_times))]\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.ylabel(\"secs\")\n",
    "plt.plot(x, epoch_times, label=\"Regular training\", color=\"red\")\n",
    "plt.plot(x, m_epoch_times, label=\"Fast training\", color=\"green\")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.legend(loc=\"best\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot total time to achieve metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_best_metric_time(threshold, best_values):\n",
    "    for i, v in enumerate(best_values[0]):\n",
    "        if v > threshold:\n",
    "            return best_values[2][i]\n",
    "    return -1\n",
    "\n",
    "\n",
    "def get_best_metric_epochs(threshold, best_values):\n",
    "    for i, v in enumerate(best_values[0]):\n",
    "        if v > threshold:\n",
    "            return best_values[1][i]\n",
    "    return -1\n",
    "\n",
    "\n",
    "def get_label(index):\n",
    "    if index == 0:\n",
    "        return \"Regular training\"\n",
    "    elif index == 1:\n",
    "        return \"Fast training\"\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "\n",
    "plt.figure(\"train\", (18, 6))\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.title(\"Metrics Time\")\n",
    "plt.xlabel(\"secs\")\n",
    "plt.ylabel(\"best mean_dice\")\n",
    "plt.plot(best[2], best[0], label=\"Regular training\", color=\"red\")\n",
    "plt.plot(m_best[2], m_best[0], label=\"Fast training\", color=\"green\")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.title(\"Typical Metrics Time\")\n",
    "plt.xlabel(\"best mean_dice\")\n",
    "plt.ylabel(\"secs\")\n",
    "labels = [\"0.90\", \"0.90 \", \"0.93\", \"0.93 \", \"0.95\", \"0.95 \", \"0.97\", \"0.97 \"]\n",
    "x_values = [0.9, 0.9, 0.93, 0.93, 0.95, 0.95, 0.97, 0.97]\n",
    "for i, (l, x) in enumerate(zip(labels, x_values)):\n",
    "    value = int(get_best_metric_time(x, best if i % 2 == 0 else m_best))\n",
    "    color = \"red\" if i % 2 == 0 else \"green\"\n",
    "    plt.bar(l, value, 0.5, label=get_label(i), color=color)\n",
    "    plt.text(l, value, \"%s\" % value, ha=\"center\", va=\"bottom\")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.title(\"Typical Metrics Epochs\")\n",
    "plt.xlabel(\"best mean_dice\")\n",
    "plt.ylabel(\"epochs\")\n",
    "for i, (l, x) in enumerate(zip(labels, x_values)):\n",
    "    value = int(get_best_metric_epochs(x, best if i % 2 == 0 else m_best))\n",
    "    color = \"red\" if i % 2 == 0 else \"green\"\n",
    "    plt.bar(l, value, 0.5, label=get_label(i), color=color)\n",
    "    plt.text(l, value, \"%s\" % value, ha=\"center\", va=\"bottom\")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.legend(loc=\"best\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cleanup data directory\n",
    "\n",
    "Remove directory if a temporary was used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if directory is None:\n",
    "    shutil.rmtree(root_dir)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
